home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / Xpm / pixmap / Extensions.c < prev    next >
Text File  |  1994-08-01  |  11KB  |  375 lines
  1. /*
  2.  * $Id: Extensions.c,v 1.2 1992/10/27 08:33:15 mallet Exp $
  3.  *
  4.  * Copyright 1992 Lionel Mallet
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appears in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of Lionel MALLET not be used in
  11.  * advertising or publicity pertaining to distribution of the software
  12.  * without specific, written prior permission.  Lionel MALLET makes no
  13.  * representations about the suitability of this software for any
  14.  * purpose.  It is provided "as is" without express or implied warranty.
  15.  *
  16.  * Lionel MALLET DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17.  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  18.  * FITNESS, IN NO EVENT SHALL Lionel MALLET BE LIABLE FOR ANY SPECIAL,
  19.  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  20.  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  21.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  22.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  23.  *
  24.  *  This software is opened and free. Furthermore, everybody is kindly
  25.  * invited to participate to improve it for the benefit of all.
  26.  * Improvements can be new features, bugs fixes and porting issues
  27.  * resolution.
  28.  *
  29.  * Author:  Tim Wise - Scientific & Engineering Software (SES), Inc.
  30.  */
  31.  
  32. #define UNKNOWN -1
  33.  
  34. /*****************************************************************************/
  35. /*
  36.             Extension List Routines 
  37.  
  38.     Routines to deal with array of XpmExtensions. 
  39. */
  40. /*****************************************************************************/
  41.  
  42.  
  43. /*--------------------------------------------------------------------------*/
  44. /*
  45.             C o p y E x t e n s i o n 
  46.  
  47.     Copy an xpm extension.
  48. */
  49. /*--------------------------------------------------------------------------*/
  50. void CopyExtension( dst, src )
  51.     XpmExtension *dst;
  52.     XpmExtension *src;
  53. {
  54.     int          i;
  55.  
  56.     if ( dst == NULL ) 
  57.         return;
  58.  
  59.     dst->name   = XtNewString( src->name );
  60.     dst->nlines = src->nlines;
  61.  
  62.     dst->lines  = (char **) XtCalloc( src->nlines, sizeof(char**) );
  63.     for ( i=0; i < src->nlines; i++ ) 
  64.         dst->lines[i] = XtNewString( src->lines[i] );
  65. }
  66.  
  67.  
  68. /*--------------------------------------------------------------------------*/
  69. /*
  70.             F r e e E x t e n s i o n 
  71.  
  72.     Free the name string and the lines of an XpmExtension but don't
  73.     free the XpmExtension struct itself.
  74. */
  75. /*--------------------------------------------------------------------------*/
  76. void FreeExtension( extension )
  77.     XpmExtension  *extension;
  78. {
  79.     int          i;
  80.  
  81.     if ( extension == NULL ) 
  82.         return;
  83.  
  84.     XtFree( extension->name );
  85.     for ( i=0; i < extension->nlines; i++ ) 
  86.        XtFree( extension->lines[i] );
  87.     XtFree((char *)extension->lines);
  88. }
  89.  
  90.  
  91. /*--------------------------------------------------------------------------*/
  92. /*
  93.                         F i n d E x t e n s i o n
  94.  
  95.         Find an extension given its name. If found, return index of
  96.         extension; otherwise return UNKNOWN.
  97. */
  98. /*--------------------------------------------------------------------------*/
  99. int FindExtension( exts, n, name )
  100.     XpmExtension *exts;         /* array of extensions */
  101.     int          n;             /* number of extensions in array */
  102.     char         *name;         /* name of extension to find */
  103. {
  104.     int           i;            /* index of found element */
  105.  
  106.     if ( exts == NULL ) 
  107.         return UNKNOWN;
  108.  
  109.     for (i=0; i < n; i++, exts++) {
  110.         if (strcmp(exts->name, name) == 0) {
  111.             return i;
  112.         }
  113.     }
  114.     return UNKNOWN;
  115. }
  116.  
  117.  
  118. /*--------------------------------------------------------------------------*/
  119. /*
  120.             A d d E x t e n s i o n
  121.  
  122.     Add extension with given name to end of list. Return index of 
  123.     new extension.
  124. */
  125. /*--------------------------------------------------------------------------*/
  126. int AddExtension( exts, n, name )
  127.     XpmExtension **exts;    /* array of extensions */
  128.     int         *n;        /* number of extensions in array */
  129.     char         *name;        /* name of new extension */
  130. {
  131.     XpmExtension *e;
  132.     int          i;        /* index of new element */
  133.  
  134.     if ( exts == NULL )
  135.         return UNKNOWN;
  136.  
  137.     /* allocate new extension array */
  138.     i = *n;    
  139.     (*n)++;            /* increment count */
  140.     if (*exts != NULL) 
  141.         *exts = (XpmExtension *) XtRealloc((char *)*exts,
  142.                        *n * sizeof(XpmExtension) );
  143.     else 
  144.         *exts = (XpmExtension *) XtNew( XpmExtension );
  145.  
  146.     /* put new element at end of array and initialize */
  147.     e = *exts + i;
  148.     e->name = XtNewString( name );
  149.     e->nlines = 0;
  150.     e->lines = NULL;
  151.  
  152.     return i;
  153. }
  154.  
  155.  
  156.  
  157.  
  158. /*--------------------------------------------------------------------------*/
  159. /*
  160.             R e m o v e E x t e n s i o n
  161.  
  162.     Delete extension i from list. Shift elements above i to left.
  163. */
  164. /*--------------------------------------------------------------------------*/
  165. void RemoveExtension( exts, n, i )
  166.     XpmExtension **exts;    /* array of extensions */
  167.     int         *n;        /* number of extensions in array */
  168.     int         i;        /* index to delete */
  169. {
  170.     XpmExtension *t, *s, *e, *last;
  171.     int          j;
  172.  
  173.     if ( exts == NULL || i == UNKNOWN ) 
  174.         return;
  175.  
  176.     /* free extension info */
  177.     e = *exts + i;
  178.     XtFree(e->name);
  179.     for (j = 0; j < e->nlines; j++)
  180.         if (e->lines[j] != NULL)
  181.             XtFree(e->lines[j]);
  182.     if (e->lines != NULL)
  183.         XtFree((char *)e->lines);
  184.  
  185.     last = *exts + *n;        /* last element */
  186.     (*n)--; 
  187.  
  188.     /* if other extensions, shift left those after deleted one */
  189.     /* Note: we're doing a structure assignment! */
  190.     if (*n > 0) 
  191.         for ( t=(*exts)+i, s=(*exts)+i+1; s < last ; *t++ = *s++ );
  192.     else {
  193.         XtFree((char *)*exts);
  194.         *exts = NULL;
  195.     }
  196. }
  197.  
  198.  
  199. /*--------------------------------------------------------------------------*/
  200. /*
  201.                         C o p y E x t e n s i o n s
  202.  
  203.         Copy an array of extensions.
  204. */
  205. /*--------------------------------------------------------------------------*/
  206. void CopyExtensions( dst_e, dst_n, src_e, src_n )
  207.     XpmExtension **dst_e;
  208.     int          *dst_n;
  209.     XpmExtension *src_e;
  210.     int          src_n;
  211. {
  212.     XpmExtension *te, *se;
  213.  
  214.     if ( dst_e == NULL )
  215.         return;
  216.  
  217.     *dst_e = NULL;
  218.     *dst_n = 0;
  219.  
  220.     if (src_e != NULL && src_n > 0) {
  221.         *dst_n = src_n;
  222.         *dst_e = (XpmExtension *) XtCalloc( src_n, sizeof(XpmExtension) );
  223.         for ( te = *dst_e, se = src_e; se < src_e + src_n; te++, se++ ) 
  224.             CopyExtension( te, se );
  225.     }
  226. }
  227.  
  228.  
  229.  
  230. /*--------------------------------------------------------------------------*/
  231. /*
  232.             P r i n t E x t e n s i o n s
  233. */
  234. /*--------------------------------------------------------------------------*/
  235. void PrintExtensions( exts, n )
  236.     XpmExtension *exts;
  237.     int          n;
  238. {
  239.     int i, j;
  240.     if ( exts != NULL ) {
  241.         for (i = 0; i < n; i++) {
  242.             fprintf(stderr, "Xpm extension : %s\n", exts[i].name);
  243.             for (j = 0; j < exts[i].nlines; j++) {
  244.                 fprintf( stderr, "\t\t%s\n", exts[i].lines[j] );
  245.             }
  246.         }
  247.     }
  248. }
  249.  
  250.  
  251. /*****************************************************************************/
  252. /*
  253.         Interface to PW extensions
  254. */
  255. /*****************************************************************************/
  256.  
  257.  
  258. /*--------------------------------------------------------------------------*/
  259. /*
  260.             P W G e t E x t e n s i o n N a m e s
  261.  
  262.     Return an array of extension names. The list is terminated with
  263.     a null name;
  264. */
  265. /*--------------------------------------------------------------------------*/
  266. char **PWGetExtensionNames( w )
  267.     Widget w;
  268. {
  269.     PixmapWidget PW = (PixmapWidget) w;
  270.     int          i;
  271.     char         **names = NULL;
  272.  
  273.     names = (char **) XtCalloc( PW->pixmap.nextensions + 1, sizeof(char *) );
  274.     names[ PW->pixmap.nextensions ] = NULL;
  275.  
  276.     for ( i = 0; i < PW->pixmap.nextensions ; i++ ) 
  277.         names[i] = XtNewString( PW->pixmap.extensions[i].name );
  278.  
  279.     return names;
  280. }
  281.  
  282.  
  283. /*--------------------------------------------------------------------------*/
  284. /*
  285.             P W F i n d E x t e n s i o n
  286. */
  287. /*--------------------------------------------------------------------------*/
  288. XpmExtension *PWFindExtension( w, name )
  289.     Widget w;
  290.     String name;
  291. {
  292.     PixmapWidget PW = (PixmapWidget) w;
  293.     int          i;
  294.     XpmExtension *extension = NULL;
  295.  
  296.     if ( (i=FindExtension(PW->pixmap.extensions, PW->pixmap.nextensions, name)) 
  297.         != UNKNOWN ) {
  298.         extension = XtNew( XpmExtension );
  299.         CopyExtension( extension, PW->pixmap.extensions + i );  
  300.     }
  301.  
  302.     return extension;
  303. }
  304.  
  305.  
  306. /*--------------------------------------------------------------------------*/
  307. /*
  308.             P W A d d E x t e n s i o n
  309.  
  310.     Add an extension if it doesn't already exist.
  311. */
  312. /*--------------------------------------------------------------------------*/
  313. void PWAddExtension( w, name )
  314.     Widget w;
  315.     String name;
  316. {
  317.     PixmapWidget PW = (PixmapWidget) w;
  318.  
  319.     if ( FindExtension(PW->pixmap.extensions, PW->pixmap.nextensions, name)
  320.          == UNKNOWN ) {
  321.  
  322.         AddExtension( &(PW->pixmap.extensions), 
  323.                       &(PW->pixmap.nextensions), name );
  324.     }
  325. }
  326.  
  327.  
  328. /*--------------------------------------------------------------------------*/
  329. /*
  330.             P W R e m o v e E x t e n s i o n
  331. */
  332. /*--------------------------------------------------------------------------*/
  333. void PWRemoveExtension( w, name )
  334.     Widget w;
  335.     String name;
  336. {
  337.     PixmapWidget PW = (PixmapWidget) w;
  338.     int          i;
  339.     XpmExtension *extension = NULL;
  340.  
  341.     if ( (i=FindExtension(PW->pixmap.extensions, PW->pixmap.nextensions, name))
  342.          != UNKNOWN ) {
  343.  
  344.         RemoveExtension(&(PW->pixmap.extensions), &(PW->pixmap.nextensions), i);
  345.     }
  346. }
  347.  
  348.  
  349. /*--------------------------------------------------------------------------*/
  350. /*
  351.             P W U p d a t e  E x t e n s i o n
  352. */
  353. /*--------------------------------------------------------------------------*/
  354. void PWUpdateExtension( w, new_extension )
  355.     Widget w;
  356.     XpmExtension *new_extension;
  357. {
  358.     PixmapWidget PW = (PixmapWidget) w;
  359.     int          i;
  360.     XpmExtension *extension = NULL;
  361.  
  362.     if ( (i=FindExtension(PW->pixmap.extensions, PW->pixmap.nextensions, 
  363.                           new_extension->name))
  364.          != UNKNOWN ){
  365.  
  366.         if ( new_extension->nlines > 0 ) {
  367.             FreeExtension( PW->pixmap.extensions + i );
  368.             CopyExtension( PW->pixmap.extensions + i, new_extension );
  369.         } else {
  370.             RemoveExtension( &(PW->pixmap.extensions), 
  371.                              &(PW->pixmap.nextensions), i );
  372.         }
  373.     }
  374. }
  375.